<template>
  <div class="custom-container p-5">
    <div class="sele_box">
      <div style="display: flex;">
        <div style="margin-left: 10px;color:#fff;display: flex;align-items: center">
          <span style="">射频通道：</span>
          <!-- <a-select ref="select" v-model:value="nowRfin" style="width: 200px" :disabled="flag3"
                                              :placeholder="t('routes.demo.inet.rfin_placeholder')">
                                              <a-select-option :value="item.id" v-for="item in rfinOptions" :key="item.id"
                                                @click="changeck2(item.name,item.id)">
                                                {{item.name}}</a-select-option>
                                            </a-select> -->
          <a-select ref="select" v-model:value="nowRfin" style="width: 200px"
            :placeholder="t('routes.demo.inet.rfin_placeholder')">
            <a-select-option :value="item.id" v-for="item in rfinOptions" :key="item.id"
              @click="changeck2(item.name,item.id)">
              {{item.name}}</a-select-option>
          </a-select>
        </div>
        <div style="color: #fff;margin-left: 20px;display: flex;align-items: center">
          <span>卫星名：</span>
          <!-- <a-input class="ipt" v-model:value="values" :disabled="flag3" placeholder="" @blur="handleBlur"
                                              @keydown.enter="handleBlur" /> -->
          <p style="margin-bottom: 0;">{{ values }}</p>
        </div>
      </div>
  
      <a-select ref="select" v-model:value="ipData" style="margin-bottom: 10px;width: 145px;" :placeholder="'请选择Modem'"
        allowClearget_mset>
        <a-select-option :value="item.value" @click="changeck(item.ip, item.label)" v-for="item in typeOptions"
          :key="item.id">{{
          item.ip
          }}</a-select-option>
      </a-select>
    </div>
  
    <!-- <div class="menu_list">
                                                                                      <div class="menu_list_item" :class="nowstep != item.ip ? '' : 'iscked'" v-for="item in appStore.panes"
                                                                                        @click="changeck(item.ip, item.mtype)"> -->
    <!--<img :src="img1" width="150" v-if="item.status==1">
                                                                                              <img :src="img2" width="150" v-else-if="item.status==2">
                                                                                              <img :src="img3" width="150" v-else>-->
    <!-- <p class="pa1">{{ item.ip }}</p>
                                                                                        <p class="pa2">Modem类型:{{ item.mtype }}</p>
                                                                                        <p class="pa3" @click="showModal(item)">X</p>
                                                                                        <a-modal :maskClosable="false" v-model:visible="visible" :maskStyle="{ 'opacity': '0.1 !important' }"
                                                                                          title="确定删除该设备吗？" @ok="handleOk()">
                                                                                        </a-modal>
                                                                                      </div> -->
    <!--<div class="icon2">
                                                                                              <Icon icon="ci:add-plus-square" color="#52c41a" :size="40" />
                                                                                            </div>-->
    <!-- </div> -->
    <div>
      <a-row :gutter="16">
        <a-col :span="spana1" style="flex:0 0 100%;max-width:100%">
          <div class="box_tit">
            {{ t('routes.demo.inet.spectrum') }}
            <span class="moreset" @click="showEdit1">
              刷新间隔：{{ inr }}
              <FormOutlined />
            </span>
          </div>
          <div class="box_con char1" style="width:100%;height: 400px;">
            <!--<charts  class="enter-y" />-->
            <div class="notice1" v-if="nodata1">
              暂无数据！
            </div>
            <div ref="chartRef" style="width: 100%;height: 380px;" v-else></div>
          </div>
        </a-col>
        <!-- <a-col :span="6" v-if="smallsize">
                                                                                    <div class="box_tit">
                                                                                      {{ t('routes.demo.inet.signal_detection_results') }}
                                                                                      <span class="buttona1" @click="switchsize">
                                                                                        <FullscreenOutlined />
                                                                                      </span>
                                                                                    </div>
                                                                                    <div class="box_con" style="height: 400px;">
                                                                                      <a-table class="ant-table-striped" :columns="columns2" :data-source="dataList2" size="middle"
                                                                                        :rowKey="(record, index) => { return index }"
                                                                                        :rowClassName="(record, index) => (index % 2 === 1 ? 'table-striped' : null)" :pagination="false">
                                                                                      </a-table>
                                                                                    </div>
                                                                                  </a-col> -->
        <a-col :span="24">
          <div class="boxe1">
            <a-row :gutter="16">
              <a-col :span="24">
                <div class="box_tit">
                  {{ t('routes.demo.inet.sacn_log') }}
                  <span v-if="flag" style="margin-left: 20px;">
                    <a-spin />
                  </span>
                  <!-- <span class="buttona1" @click="switchsize">
                                                                                              <ExpandAltOutlined />
                                                                                              <FullscreenExitOutlined />
                                                                                            </span> -->
                </div>
                <div class="box_con" style="padding-top: 30px;">
                  <a-form :model="startParams" :labelCol="{ span: 5 }" :wrapperCol="{ span: 18 }" ref="startFormRef">
                    <a-row>
                      <!-- <a-col :span="6">
                                                                                    <a-form-item :label="t('routes.demo.inet.rfin_title')">
                                                                                      <a-select ref="select" v-model:value="nowRfin" style="width: 100%"
                                                                                        :placeholder="t('routes.demo.inet.rfin_placeholder')">
                                                                                        <a-select-option :value="item.id" v-for="item in rfinOptions" :key="item.id">
                                                                                          {{item.name}}</a-select-option>
                                                                                      </a-select>
                                                                                    </a-form-item>
                                                                                  </a-col> -->
  
                      <a-col :span="6">
                        <a-form-item :label="t('routes.demo.inet.starting_frequency_title')" name="st"><!--起始频率950-->
                          <a-input v-model:value="startParams.st"
                            :placeholder="t('routes.demo.inet.starting_frequency_placeholder')" />(MHz)
                        </a-form-item>
                      </a-col>
                      <a-col :span="6">
                        <a-form-item :label="t('routes.demo.inet.cut_off_frequency_title')" name="end"><!--截止频率2150-->
                          <a-input v-model:value="startParams.end"
                            :placeholder="t('routes.demo.inet.cut_off_frequency_placeholder')" />(MHz)
                        </a-form-item>
                      </a-col>
                      <a-col :span="7">
                        <a-form-item :label="t('routes.demo.inet.minimum_symbol_rate_title')"
                          name="rs_mix"><!--最小符号速率1~50-->
                          <a-input v-model:value="startParams.rs_mix"
                            :placeholder="t('routes.demo.inet.minimum_symbol_rate_placeholder')" />(MS/s)
                        </a-form-item>
                      </a-col>
                      <a-col :span="5">
                        <a-form-item :label="t('routes.demo.inet.scanning_step_title')" name="step"><!--扫描步进5-70-->
                          <a-input v-model:value="startParams.step"
                            :placeholder="t('routes.demo.inet.scanning_step_placeholder')" />(MHz):
                        </a-form-item>
                      </a-col>
                    </a-row>
  
                    <a-row>
  
                      <a-col :span="22" :offset="1"></a-col>
                      <a-col :span="12" :offset="12">
                        <a-form-item>
                          <a-button type="primary" v-if="flags && flag2" @click="do_start" style="margin-right: 15px;">{{
                            t('routes.demo.inet.start')
                            }}</a-button>
                          <a-button type="primary" v-else disabled style="margin-right: 15px;">{{
                            t('routes.demo.inet.start')
                            }}</a-button>
                          <a-button type="primary" danger v-if="flag2" @click="do_end" style="margin-right: 15px;">{{
                            t('routes.demo.inet.cancel')
                            }}</a-button>
                          <a-button type="primary" danger v-else disabled style="margin-right: 15px;">{{
                            t('routes.demo.inet.cancel')
                            }}</a-button>
                          <a-button color="warning" type="primary" @click="showEdit">{{
                            t('routes.demo.inet.high')
                            }}</a-button>
  
                        </a-form-item>
                      </a-col>
                    </a-row>
                  </a-form>
                  <a-row style="margin-bottom: 30px;">
                    <a-col :span="12" :offset="6">
                      扫描进度：
                      <a-progress :percent="progress" :width="110" />
                      <span class="spanaa1">持续时间：{{ time }}</span>
                    </a-col>
  
                  </a-row>
                  <a-row>
                    <a-col>
                      <a-table class="ant-table-striped tablea1" :columns="columns" :data-source="dataList" size="middle"
                        :rowKey="(record, index) => { return index }"
                        :rowClassName="(record, index) => (index % 2 === 1 ? 'table-striped' : null)" :pagination="false">
                        <template #action="{ record }">
                          <a-switch v-model:checked="record.switch" />
                        </template>
                        <template #action1="{ record }">
                          <a-button type="link" size="small" preIcon="ant-design:play-circle-outlined"
                            @click="dobind(record)">绑定通道
                          </a-button>
                        </template>
                      </a-table>
                    </a-col>
                  </a-row>
                </div>
              </a-col>
            </a-row>
          </div>
        </a-col>
      </a-row>
  
      <!-- <a-row :gutter="16" style="margin-top: 30px;" v-if="smallsize">
                                                                                  <a-col :span="24">
                                                                                    <div class="box_tit">
                                                                                      {{ t('routes.demo.inet.demodulator_status') }}
                                                                                    </div>
                                                                                    <div class="box_con" style="height: 250px;">
                                                                                      <a-table class="ant-table-striped" :columns="columns3" :data-source="dataList3" size="middle"
                                                                                        :loading="loading3" :rowKey="(record, index) => { return index }"
                                                                                        :rowClassName="(record, index) => (index % 2 === 1 ? 'table-striped' : null)" :pagination="false">
                                                                                        <template #action="{ record, index }">
                                                                                          <a-switch v-model:checked="record.stat" :checkedValue="1" :unCheckedValue="0"
                                                                                            @change="do_switch(record.stat, record.ip, record.chn, index)" :loading="switchLoading[index]" />
                                                                                        </template>
                                                                                        <template #action1="{ record }">
                                                                                          {{ record.lock == 1 ? '锁定' : '未锁' }}
                                                                                        </template>
                                                                                        <template #action2="{ record }">
                                                                                          {{ record.de_lock == 1 ? '锁定' : '未锁' }}
                                                                                        </template>
                                                                                        <template #action3="{ record }">
                                                                                          {{ record.demod_lock == 1 ? '锁定' : '未锁' }}
                                                                                        </template>
                                                                            
                                                                                      </a-table>
                                                                                    </div>
                                                                                  </a-col>
                                                                                </a-row> -->
    </div>
  
    <!-- <div v-show="nowtype != 'MT710A'">
                                                                                <a-row :gutter="16" style="margin-top: 30px;">
                                                                                  <a-col :span="24">
                                                                                    <div class="box_tit">
                                                                                      {{ t('routes.demo.inet.signal_detection_results') }}
                                                                                    </div>
                                                                                    <div class="box_con">
                                                                                      <a-table class="ant-table-striped" :columns="columns7" :data-source="dataList7" size="middle"
                                                                                        :rowKey="(record, index) => { return index }"
                                                                                        :rowClassName="(record, index) => (index % 2 === 1 ? 'table-striped' : null)"
                                                                                        :pagination="paginationOption7">
                                                                            
                                                                                      </a-table>
                                                                                    </div>
                                                                                  </a-col>
                                                                                </a-row>
                                                                              </div> -->
  
    <a-modal v-model:visible="openEditRecord" title="高级设置" width="30%" :footer="null">
      <div class="p-5">
        <a-row type="flex" justify="center" align="top">
          <a-form style="width: 80%;padding-top: 20px;" :label-col="labelCol" :wrapper-col="wrapperCol">
            <a-col :span="24">
              <a-form-item :label="t('routes.demo.inet.scan_mode_title')">
                <a-select ref="select" v-model:value="scanparam.scan_mode" style="width: 100%"
                  :placeholder="t('routes.demo.inet.scan_mode_placeholder')">
                  <a-select-option :value="item.id" v-for="item in scanOptions" :key="item.id">{{ item.name
                    }}</a-select-option>
                </a-select>
              </a-form-item>
            </a-col>
            <a-col :span="24">
              <a-form-item :label="t('routes.demo.inet.FEC_lock_title')">
                <a-select ref="select" v-model:value="scanparam.fec_lock_check" style="width: 100%"
                  :placeholder="t('routes.demo.inet.FEC_lock_placeholder')">
                  <a-select-option :value="item.id" v-for="item in flockOptions" :key="item.id">{{
                    item.name
                    }}</a-select-option>
                </a-select>
              </a-form-item>
            </a-col>
            <a-col :span="24">
              <a-form-item :label="t('routes.demo.inet.MERGER_lock_title')">
                <a-select ref="select" v-model:value="scanparam.merger_lock_check" style="width: 100%"
                  :placeholder="t('routes.demo.inet.MERGER_lock_placeholder')">
                  <a-select-option :value="item.id" v-for="item in mlockOptions" :key="item.id">{{
                    item.name
                    }}</a-select-option>
                </a-select>
              </a-form-item>
            </a-col>
            <a-col :span="24">
              <a-form-item :label="t('routes.demo.inet.Scan_timeout_title')">
                <a-input v-model:value="scanparam.out_time"
                  :placeholder="t('routes.demo.inet.Scan_timeout_placeholder')" />2000~16000（单位ms）
              </a-form-item>
            </a-col>
            <a-col :span="24">
              <a-form-item :wrapper-col="{ span: 14, offset: 6 }">
                <a-button type="primary" @click="do_Save">提交</a-button>
              </a-form-item>
            </a-col>
          </a-form>
        </a-row>
      </div>
    </a-modal>
    <a-modal v-model:visible="openbindRecord" title="绑定通道" width="30%" :footer="null">
      <div class="p-5">
        <a-row type="flex" justify="center" align="top">
          <a-form style="width: 80%;padding-top: 20px;" :label-col="labelCol" :wrapper-col="wrapperCol">
            <a-col :span="24">
              <a-form-item :label="t('routes.demo.inet.bindchn_title')">
                <a-select ref="select" v-model:value="bindparam.chn" style="width: 100%;color: #000;"
                  :placeholder="t('routes.demo.inet.bindchn_placeholder')">
                  <a-select-option :value="item.value" v-for="item in Options" :key="item.value">{{ item.label
                    }}</a-select-option>
                </a-select>
              </a-form-item>
            </a-col>
  
            <a-col :span="24">
              <a-form-item :wrapper-col="{ span: 14, offset: 6 }">
                <a-button type="primary" @click="do_bing_Save">绑定</a-button>
              </a-form-item>
            </a-col>
          </a-form>
        </a-row>
      </div>
    </a-modal>
    <a-modal v-model:visible="openInrRecord" title="刷新时间设置" width="30%" :footer="null">
      <div class="p-5">
        <a-row type="flex" justify="center" align="top">
          <a-form style="width: 80%;padding-top: 20px;" :label-col="labelCol" :wrapper-col="wrapperCol">
            <a-col :span="24">
              <a-form-item :label="t('routes.demo.inet.time_interval_title')">
                <a-input v-model:value="inr_value" :placeholder="t('routes.demo.inet.time_interval_placeholder')" />（单位/秒）
              </a-form-item>
            </a-col>
            <a-col :span="24">
              <a-form-item :wrapper-col="{ span: 14, offset: 6 }">
                <a-button type="primary" @click="do_interval_Save">提交</a-button>
              </a-form-item>
            </a-col>
          </a-form>
        </a-row>
      </div>
    </a-modal>
  
  </div>
</template>
<script lang="ts">
import { useAppStore } from '/@/store/modules/app.ts';
import { defineComponent, onMounted, onBeforeUnmount, reactive, ref, Ref, watch } from "vue";
import charts from './charts.vue';
import { Icon } from '/@/components/Icon';
import { Tag, Card } from 'ant-design-vue';
import { useRoute } from "vue-router";
import { get_signal, get_modem, get_channel, get_mset, del_modem, get_record, get_scanparam, set_sat, get_satn, get_scanresult, save_scanparam, scanset, sscan, stscan, get_term, set_status, set_inr, get_inr, get_rfin, set_rfin } from "/@/api/biz/index";
//import { ExclamationCircleOutlined, PoweroffOutlined, StarTwoTone } from '@ant-design/icons-vue';
import { ExpandAltOutlined, ExpandOutlined, FullscreenOutlined, FullscreenExitOutlined, FormOutlined } from '@ant-design/icons-vue';
import img1 from '/@/assets/images/222.png';
import img2 from '/@/assets/images/223.png';
import img3 from '/@/assets/images/224.png';
import { useI18n } from '/@/hooks/web/useI18n';
import { message } from "ant-design-vue";
import { useGo } from "/@/hooks/web/usePage";
import { useECharts } from '/@/hooks/web/useECharts';
import { get_chars } from "/@/api/biz/echarts";
import { AnymatchFn } from 'vite';
import axios from 'axios'

export default defineComponent({
  components: {
    //charts,
    ExpandAltOutlined,
    FormOutlined,
    ExpandOutlined,
    FullscreenOutlined,
    FullscreenExitOutlined,
    Icon,
  },
  setup() {
    // 定义一个响应式变量 nowRfin，用于存储当前的 RFIN 数据
    const nowRfin = ref()

    // 定义一个异步函数 do_rfin，用于获取 RFIN 数据
    async function do_rfin() {
      // 使用 axios 发起 GET 请求，获取 RFIN 数据
      await get_rfin({ ip: ipData.value }).then((res) => {
        // 将返回的 RFIN 数据赋值给 nowRfin
        nowRfin.value = res.data.data.result.data.data
      })
    }

    // 定义一个响应式变量 values，用于存储卫星数据
    let values = ref('')

    // 使用 useAppStore 获取应用状态管理对象
    const appStore = useAppStore();

    // 定义一个函数 get_sat，用于获取卫星数据
    function get_sat() {
      // 使用 axios 发起 GET 请求，获取卫星数据
      get_satn({ ip: ipData.value, rfin: nowRfin.value }).then((res) => {
        // 将返回的卫星数据赋值给 values
        values.value = res.data.data.result.data.data.sat
      })
    }

    // 定义一个响应式字符串变量 ipData，用于存储 IP 地址
    const ipData = ref('')

    // 定义一个函数 get_modems，用于获取调制解调器列表并更新相关数据
    function get_modems() {
      // 使用 axios 发起 GET 请求，获取调制解调器数据
      axios.get('/api/modem').then((res) => {
        // 检查响应数据中的数据长度是否大于 0
        if (res.data.data.result.data.length > 0) {
          // 遍历响应数据中的结果数据
          res.data.data.result.data.forEach((item) => {
            // 如果调制解调器的类型为 'MT710A'，则将其信息添加到 typeOptions 数组中
            if (item.mtype == 'MT710A') {
              typeOptions.value.push({
                value: item.id, // 调制解调器的 ID
                label: item.mtype, // 调制解调器的类型
                ip: item.ip // 调制解调器的 IP 地址
              })
            }
          })
          // 将第一个调制解调器的 IP 地址赋值给 ipData
          ipData.value = res.data.data.result.data[0].ip
          // 设置 flags 为 true，表示存在 'MT710A' 类型的调制解调器
          flags.value = true
        } else {
          // 如果没有数据，设置 flags 为 false
          flags.value = false
        }
      })
    }


    const chartRef = ref<HTMLDivElement | null>(null);
    const { setOptions, resize, echarts, getInstance } = useECharts(chartRef as Ref<HTMLDivElement>);
    const time1 = ref()
    let timerId1: ReturnType<typeof setInterval> | null;
    let timerId2: ReturnType<typeof setInterval> | null;
    let timerId3: ReturnType<typeof setInterval> | null;
    const typeOptions = ref([
      // {
      //   value: '1',
      //   label: 'M710a',
      //   ip: '182.32.19.23'
      // },
      // {
      //   value: '2',
      //   label: 'M650',
      //   ip: '182.32.19.234'
      // },
    ]);
    let select1 = ref();
    let flags = ref(true)

    select1.value = appStore.obj.type || null
    watch(nowRfin, (newVal, oldVal) => {
      if (newVal !== undefined) {
        get_sat();
      }
    });
    onMounted(() => {
      const router = useRoute()
      const ip = appStore.obj.ip
      const mtype = appStore.obj.type
      queryParams2.ip = ip
      queryParams3.ip = ip
      queryParams4.ip = ip
      queryParams5.ip = ip
      queryParams6.ip = ip
      queryParams7.ip = ip
      nowstep.value = ip
      nowtype.value = mtype
      scanparam.ip = ip
      getParams.ip = ip
      startParams.ip = ip
      endParams.ip = ip
      bindparam.ip = ip

      get_modems();
      get_chars()
      firstload()
      timerId1 = setInterval(() => {
        if (nowtype.value == 'MT710A') {
          getList3();
        } else {
          getList7();
        }
      }, 10000);
      timerId2 = setInterval(() => {
        if (nowtype.value == 'MT710A') {
          getList2();
          getModems();
        }
      }, 10000);
      //监控datazoom的变化，给全局datazoom送参数，防止刷新数据时缩放还原初始
      let aa = getInstance()
      aa.on('dataZoom', function (event) {
        if (event.batch) {
          datax1.start = event.batch[0].start
          datax1.end = event.batch[0].end
        } else {
          datax1.start = event.start
          datax1.end = event.end
        }
        datax1.dataZoom[0].start = datax1.start
        datax1.dataZoom[0].end = datax1.end
      })

    });
    onBeforeUnmount(() => {
      timerId1 && window.clearInterval(timerId1);
      timerId2 && window.clearInterval(timerId2);
      timerId3 && window.clearInterval(timerId3);
    });
    watch(time1, (newValue) => {
      if (newValue) {
        startInterval();
      }
    });
    watch(ipData, (newValue) => {
      if (newValue) {
        do_rfin();
        get_sat()
      }
    });
    const { t } = useI18n();
    const columns = [
      {
        title: t('routes.demo.inet.center_frequency'),
        dataIndex: 'cf',
      },
      {
        title: t('routes.demo.inet.rf_frequency'),//射频频率
        dataIndex: 'cf',
      },

      {
        title: t('routes.demo.inet.symbol_rate'),
        align: "center",
        dataIndex: 'rt',
      },
      {
        title: t('routes.demo.inet.signal_to_noise_ratio'),
        align: "center",
        dataIndex: "snr"
      },
      {
        title: t('routes.demo.inet.standard'),
        align: "center",
        dataIndex: 'std',
      },
      {
        title: t('routes.demo.inet.pilots'),
        align: "center",
        dataIndex: 'pilots',
      },
      {
        title: t('routes.demo.inet.encoding'),
        align: "center",
        dataIndex: 'encoding',
      },
      {
        title: t('routes.demo.inet.frame_length_type'),
        align: "center",
        dataIndex: "frame_len"
      },
      {
        title: t('routes.demo.inet.rolloff_factor'),
        align: "center",
        dataIndex: 'rdc',
      },
      {
        title: t('routes.demo.inet.operate'),
        align: "center",
        dataIndex: 'lock',
        slots: { customRender: 'action1' },
      },
    ]
    const columns2 = [
      {
        title: t('routes.demo.inet.frequency'),
        align: "center",
        dataIndex: 'cf',
      },
      {
        title: t('routes.demo.inet.symbol_rate'),
        align: "center",
        dataIndex: 'rt',
      },
      {
        title: t('routes.demo.inet.ModCode'),
        align: "center",
        dataIndex: "modcode"
      },
      {
        title: t('routes.demo.inet.roll_off_factor'),
        align: "center",
        dataIndex: 'rdc',
      },
      {
        title: t('routes.demo.inet.frame_length_type'),
        align: "center",
        dataIndex: 'frame_len',
      }
    ]
    const columns3 = [
      {
        title: t('routes.demo.inet.channel_number'),
        align: "center",
        dataIndex: 'chn',
      },
      {
        title: t('routes.demo.inet.center_frequency'),
        align: "center",
        dataIndex: 'cf',
      },
      {
        title: t('routes.demo.inet.symbol_rate'),
        align: "center",
        dataIndex: "rt"
      },
      {
        title: t('routes.demo.inet.channel_locking'),
        align: "center",
        dataIndex: 'lock',
        slots: { customRender: 'action1' },
      },
      {
        title: t('routes.demo.inet.decoding_lock'),
        align: "center",
        dataIndex: 'de_lock',
        slots: { customRender: 'action2' },
      },
      {
        title: t('routes.demo.inet.demodulation_lock'),
        align: "center",
        dataIndex: 'demod_lock',
        slots: { customRender: 'action3' },
      },
      {
        title: t('routes.demo.inet.signal_power'),
        align: "center",
        dataIndex: 'sp',
      },
      {
        title: t('routes.demo.inet.signal_to_noise_ratio'),
        align: "center",
        dataIndex: 'snr',

      },
      {
        title: t('routes.demo.inet.error_rate'),
        align: "center",
        dataIndex: 'ser',

      },
      {
        title: t('routes.demo.inet.frequency_offset'),
        align: "center",
        dataIndex: 'fs',
      },
      {
        title: t('routes.demo.inet.collection_end'),
        align: "center",
        dataIndex: 'rts',
        slots: { customRender: 'action' },
      },
      {
        title: t('routes.demo.inet.collect_information'),
        align: "center",
        dataIndex: 'base_path',
      },

    ]
    const columns4 = [
      {
        title: '落盘时间',
        dataIndex: 'name',
      },
      {
        title: '频率',
        align: "center",
        dataIndex: 'industry',
      },
      {
        title: '解调通道',
        align: "center",
        dataIndex: 'region',
      },
      {
        title: "文件编号",
        align: "center",
        dataIndex: "phone"
      },
      {
        title: '文件大小(KB)',
        align: "center",
        dataIndex: 'notice_time',
      },
      {
        title: '文件类型',
        align: "center",
        dataIndex: 'notice_num',
      },
      {
        title: '下载地址',
        align: "center",
        dataIndex: 'status',
      }
    ]
    const columns7 = [
      {
        title: '通道号',
        dataIndex: 'chn_num',
      },
      {
        title: '数据类型',
        align: "center",
        dataIndex: 'data_type',
      },
      {
        title: '数据处理方式',
        align: "center",
        dataIndex: 'data_processing',
      },
      {
        title: "处理内容",
        align: "center",
        dataIndex: "content"
      },
      {
        title: '时间',
        align: "center",
        dataIndex: 'update_time',
      },
    ]
    const switchLoading = reactive(
      [
        false,
        false,
        false,
        false,
      ]
    )
    // 定义一个响应式变量 inr，用于存储某个值
    const inr = ref()

    // 定义一个响应式变量 inr_value，初始值为 0，用于存储 inr 的值
    const inr_value = ref(0)

    // 定义一个响应式变量 spana1，初始值为 18，用于存储 span 的宽度或大小
    const spana1 = ref(18)

    // 定义一个响应式布尔变量 smallsize，初始值为 true，用于控制大小状态
    const smallsize = ref(true)

    // 定义一个响应式变量 nowstep，用于存储当前的步骤
    const nowstep = ref('')

    // 定义一个响应式变量 nowtype，用于存储当前的类型
    const nowtype = ref('')

    // 定义一个响应式变量 arr，用于存储数组
    const arr = ref('')

    // 定义多个响应式变量 activeKey1, activeKey2, activeKey3, activeKey4，用于存储激活的键值
    const activeKey1 = ref([]);
    const activeKey2 = ref([]);
    const activeKey3 = ref([]);
    const activeKey4 = ref([]);

    // 定义一个响应式变量 progress，用于存储进度值
    const progress = ref()

    // 定义一个响应式变量 time，用于存储时间
    const time = ref('')

    // 定义一个响应式变量 rfinOptions，用于存储 RFIN 选项
    const rfinOptions = ref([
      { name: 2, id: '2' }, // RFIN 选项 2
      { name: 3, id: '3' }, // RFIN 选项 3
      { name: 4, id: '4' }, // RFIN 选项 4
    ]);

    // 定义一个响应式变量 scanOptions，用于存储扫描选项
    const scanOptions = ref([]);

    // 定义一个响应式变量 flockOptions，用于存储 flock 选项
    const flockOptions = ref([]);

    // 定义一个响应式变量 timeoutOptions，用于存储超时选项
    const timeoutOptions = ref([]);

    // 定义一个响应式变量 mlockOptions，用于存储 mlock 选项
    const mlockOptions = ref([]);

    // 定义一个响应式布尔变量 openEditRecord，用于控制编辑记录的显示状态
    const openEditRecord = ref(false);

    // 定义一个响应式布尔变量 openbindRecord，用于控制绑定记录的显示状态
    const openbindRecord = ref(false);

    // 定义一个响应式布尔变量 openInrRecord，用于控制 INR 记录的显示状态
    const openInrRecord = ref(false);

    // 定义一个响应式变量 startFormRef，用于存储表单引用
    const startFormRef = ref();

    // 定义一个响应式对象 queryParams，用于存储查询参数
    const queryParams = reactive({
      cpn: 1, // 当前页码，默认为 1
      epc: 10, // 每页显示的记录数，默认为 10
      ip: '', // IP 地址，默认为空字符串
      rfin: 2, // RFIN 值，默认为 2
    });

    // 定义一个响应式对象 getParams，用于存储获取参数
    const getParams = reactive({
      ip: '', // IP 地址，默认为空字符串
      rfin: 2, // RFIN 值，默认为 2
    });

    const startParams = reactive({
      ip: '',
      rfin: 2,
      step: 5,
      st: 950,
      end: 2150,
      rs_mix: 1,
    });
    const endParams = reactive({
      ip: '',
      rfin: 2,
    });
    const scanparam = reactive({
      ip: '',
      scan_mode: undefined,
      fec_lock_check: undefined,
      merger_lock_check: undefined,
      out_time: undefined,
    });
    const bindparam = reactive({
      ip: '',
      chn: undefined,
      index: undefined,
    });

    const queryParams2 = reactive({
      cpn: 1,
      epc: 10,
      ip: '',
    })
    const queryParams3 = reactive({
      cpn: 1,
      epc: 10,
      ip: '',
    })
    const queryParams4 = reactive({
      cpn: 1,
      epc: 10,
      ip: '',
    })
    const queryParams5 = reactive({
      ip: '',
    })
    const queryParams6 = reactive({
      cpn: 1,
      epc: 10,
      ip: '',
      rfin: 2,
    })
    const queryParams7 = reactive({
      cpn: 1,
      epc: 10,
      ip: '',
    })
    const delParams = reactive({
      ip: 0
    })
    const saveParams3 = reactive({
      ip: '',
      chn: 1,
      status: 0,

    });
    const dataList = ref([])
    const Options = reactive([
      { value: 1, label: '通道1' },
      { value: 2, label: '通道2' },
      { value: 3, label: '通道3' },
      { value: 4, label: '通道4' },
    ]);
    const dataList2 = ref([])
    const dataList3 = ref([])
    const dataList4 = ref([])
    const dataList7 = ref([])
    const xdata = ref([])
    const ydata = ref([])
    const loading = ref(false)
    const loading3 = ref(false)
    const nodata1 = ref(false)
    const flag = ref(true)
    const rules = {
      st: [
        { required: true, message: '请填写', trigger: 'blur' },
        { min: 950, max: 2150, message: '范围950~2150', trigger: 'blur' },
      ],
      end: [
        { required: true, message: '请填写', trigger: 'blur' },
        { min: 950, max: 2150, message: '范围950~2150', trigger: 'blur' },
      ],
      rs_mix: [
        { required: true, message: '请填写', trigger: 'blur' },
        { min: 1, max: 50, message: '范围1~50', trigger: 'blur' },
      ],
      step: [
        { required: true, message: '请填写', trigger: 'blur' },
        { min: 5, max: 70, message: '范围5~70', trigger: 'blur' },
      ]
    };
    const paginationOption2 = reactive({
      showSizeChanger: true,
      total: 0,
      current: 1,
      onChange: changePageInfo2,
      onShowSizeChange: changePageInfo2
    });
    const paginationOption3 = reactive({
      showSizeChanger: true,
      total: 0,
      current: 1,
      onChange: changePageInfo3,
      onShowSizeChange: changePageInfo3
    });
    const paginationOption4 = reactive({
      showSizeChanger: true,
      total: 0,
      current: 1,
      onChange: changePageInfo4,
      onShowSizeChange: changePageInfo4
    });
    const paginationOption7 = reactive({
      total: 0,
      current: 1,
      onChange: changePageInfo7,
      onShowSizeChange: changePageInfo7
    });
    const visible = ref<boolean>(false);
    function showModal(item) {
      delParams.ip = item.ip
      visible.value = true;
    };
    // 定义一个函数 handleOk，用于处理调制解调器的删除操作
    function handleOk() {
      // 调用 del_modem 函数，传入 delParams 参数，删除指定的调制解调器
      del_modem(delParams).then((res) => {
        // 检查响应状态是否为 200
        if (res.status == 200) {
          message.success('删除成功'); // 显示成功消息
          getModems(); // 重新获取调制解调器列表
        } else {
          message.error('删除失败'); // 显示失败消息
        }
      });
      visible.value = false; // 关闭当前对话框
    }

    // 定义一个函数 startInterval，用于启动定时器
    function startInterval() {
      // 设置一个定时器，每隔 time1.value 毫秒执行一次 do_load_chars 函数
      timerId3 = setInterval(() => {
        console.log('time1', time1.value); // 打印当前 time1 的值
        do_load_chars(); // 执行 do_load_chars 函数
      }, time1.value);
    }

    // 定义一个函数 changePageInfo2，用于改变分页信息并重新获取列表数据
    function changePageInfo2(page, pageSize) {
      queryParams2.cpn = page; // 更新查询参数中的当前页码
      queryParams2.epc = pageSize; // 更新查询参数中的每页显示的记录数
      getList2(); // 重新获取列表数据
    }

    // 定义一个函数 changePageInfo3，用于改变分页信息并重新获取第三个列表数据
    function changePageInfo3(page, pageSize) {
      queryParams3.cpn = page; // 更新查询参数中的当前页码
      queryParams3.epc = pageSize; // 更新查询参数中的每页显示的记录数
      getList3(); // 重新获取第三个列表数据
    }

    // 定义一个函数 changePageInfo4，用于改变分页信息并重新获取调制解调器列表数据
    function changePageInfo4(page, pageSize) {
      queryParams4.cpn = page; // 更新查询参数中的当前页码
      queryParams4.epc = pageSize; // 更新查询参数中的每页显示的记录数
      getModems(); // 重新获取调制解调器列表数据
    }

    // 定义一个函数 changePageInfo7，用于改变分页信息并重新获取第七个列表数据
    function changePageInfo7(page, pageSize) {
      queryParams7.cpn = page; // 更新查询参数中的当前页码
      queryParams7.epc = pageSize; // 更新查询参数中的每页显示的记录数
      getList7(); // 重新获取第七个列表数据
    }

    // 定义一个异步函数 firstload，用于初次加载时获取数据并初始化状态
    async function firstload() {
      loading.value = true; // 设置加载状态为 true，表示正在加载数据

      // 获取应用状态管理对象中的调制解调器列表
      let ckmodems = appStore.panes;

      // 如果调制解调器列表为空
      if (ckmodems.length < 1) {
        // 调用 get_modem 函数，传入查询参数，获取调制解调器数据
        get_modem(queryParams4).then(res => {
          console.log(res); // 打印响应数据，便于调试

          // 如果 nowtype 为空且返回的数据长度大于 0，将第一个调制解调器的类型赋值给 nowtype
          if (!nowtype.value && res.data.data.result.data.length > 0) {
            nowtype.value = res.data.data.result.data[0].mtype;
          }

          // 如果 nowstep 为空且返回的数据长度大于 0，将第一个调制解调器的 IP 地址赋值给 nowstep 和相关查询参数
          if (!nowstep.value) {
            appStore.obj.ip = res.data.data.result.data[0].ip;
            queryParams3.ip = nowstep.value;
            queryParams6.ip = nowstep.value;
            queryParams5.ip = nowstep.value;
            queryParams.ip = nowstep.value;
            scanparam.ip = nowstep.value;
            getParams.ip = nowstep.value;
            startParams.ip = nowstep.value;
            endParams.ip = nowstep.value;
            bindparam.ip = nowstep.value;
          }

          // 更新应用状态管理对象中的调制解调器列表
          appStore.setPanes(res.data.data.result.data);

          // 根据 nowtype 的值决定获取哪个列表的数据
          if (nowtype.value == 'MT710A') {
            getList2(); // 获取第二个列表数据
            getList3(); // 获取第三个列表数据
            do_get_chars(); // 执行字符获取操作
            do_init(); // 执行初始化操作
            getInr(); // 获取 INR 数据
            getScanParams(); // 获取扫描参数
          } else {
            getList7(); // 获取第七个列表数据
          }

          loading.value = false; // 设置加载状态为 false，表示数据加载完成
        }).catch(() => {
          loading.value = false; // 如果发生错误，设置加载状态为 false
        });
      } else {
        // 如果调制解调器列表不为空

        // 如果 nowtype 为空且应用状态管理对象中的调制解调器列表长度大于 0，将第一个调制解调器的类型赋值给 nowtype
        if (!nowtype.value && appStore.panes.length > 0) {
          nowtype.value = appStore.panes[0].mtype;
        }

        // 如果 nowstep 为空且应用状态管理对象中的调制解调器列表长度大于 0，将第一个调制解调器的 IP 地址赋值给 nowstep 和相关查询参数
        if (!nowstep.value && appStore.panes.length > 0) {
          nowstep.value = appStore.panes[0].ip;
          queryParams3.ip = nowstep.value;
          queryParams6.ip = nowstep.value;
          queryParams5.ip = nowstep.value;
          queryParams.ip = nowstep.value;
          scanparam.ip = nowstep.value;
          getParams.ip = nowstep.value;
          startParams.ip = nowstep.value;
          endParams.ip = nowstep.value;
          bindparam.ip = nowstep.value;
        }

        // 根据 nowtype 的值决定获取哪个列表的数据
        if (nowtype.value == 'MT710A') {
          getList2(); // 获取第二个列表数据
          getList3(); // 获取第三个列表数据
          do_get_chars(); // 执行字符获取操作
          do_init(); // 执行初始化操作
          getInr(); // 获取 INR 数据
          getScanParams(); // 获取扫描参数
        } else {
          getList7(); // 获取第七个列表数据
        }
      }
    }

    // 定义一个异步函数 getList2，用于获取第二个列表的数据
    async function getList2() {
      loading.value = true; // 设置加载状态为 true，表示正在加载数据
      flag.value = true; // 设置 flag 状态为 true，可能用于控制某些 UI 元素的显示

      // 使用 axios 发起 GET 请求，获取扫描结果数据
      get_scanresult(queryParams6).then(res => {
        // 检查响应数据中的 progress 属性是否存在
        if (res.data.data.result.data.progress) {
          dataList2.value = res.data.data.result.data.chn; // 将返回的频道数据赋值给 dataList2
          dataList.value = res.data.data.result.data.chn; // 将返回的频道数据赋值给 dataList
          flag.value = false; // 设置 flag 状态为 false
        } else {
          flag.value = true; // 如果 progress 不存在，保持 flag 状态为 true
        }
        progress.value = res.data.data.result.data.progress; // 更新进度值
        time.value = res.data.data.result.data.time; // 更新时间值
        loading.value = false; // 设置加载状态为 false，表示数据加载完成
      }).catch(() => {
        loading.value = false; // 如果发生错误，设置加载状态为 false
      });
    }

    let flag2 = ref()
    let flag3 = ref()
    // 定义一个异步函数 getList3，用于获取第三个列表的数据
    async function getList3() {
      // 将 switchLoading 数组中的四个元素都设置为 false，可能用于控制开关的加载状态
      switchLoading[0] = false;
      switchLoading[1] = false;
      switchLoading[2] = false;
      switchLoading[3] = false;

      // 如果 dataList3 为空，则设置 loading3 为 true，表示正在加载数据
      if (dataList3.value.length == 0) {
        loading3.value = true;
      }

      // 使用 axios 发起 GET 请求，获取频道数据
      get_channel(queryParams3).then(res => {
        // 检查返回的数据长度是否大于 0
        if (res.data.data.result.data.length > 0) {
          // 如果数据长度大于 0，将数据赋值给 dataList3
          dataList3.value = res.data.data.result.data;

          // 检查数据中是否存在 stat 不等于 0 且 chn_type 不等于 0 的项
          const con = res.data.data.result.data.some(item => item.stat !== 0 && item.chn_type !== 0);

          // 定义一个响应式变量 con2，用于存储是否存在 stat 不等于 0 的项
          let con2 = ref();
          con2.value = res.data.data.result.data.some(item => item.stat != 0);

          // 根据 con2 的值更新 flag3 的状态
          if (con2.value) {
            flag3.value = true;
          } else {
            flag3.value = false;
          }

          // 根据 con 的值更新 flag2 的状态
          if (con) {
            flag2.value = false;
          } else {
            flag2.value = true;
          }

          // 设置 loading3 为 false，表示数据加载完成
          loading3.value = false;
        }
      }).catch(() => {
        // 如果发生错误，设置 loading3 为 false
        loading3.value = false;
      });
    }

    // 定义一个函数 getInr，用于获取 INR 数据并更新相关状态
    function getInr() {
      loading.value = true; // 设置加载状态为 true，表示正在加载数据

      // 使用 axios 发起 GET 请求，获取 INR 数据
      get_inr({}).then(res => {
        inr.value = res.data.data.result.data.inr; // 将返回的 INR 数据赋值给 inr
        time1.value = inr.value * 1000; // 将 INR 数据转换为毫秒并赋值给 time1
        loading.value = false; // 设置加载状态为 false，表示数据加载完成
      }).catch(() => {
        loading.value = false; // 如果发生错误，设置加载状态为 false
      });
    }

    // 定义一个异步函数 getModems，用于获取调制解调器列表并更新相关状态
    async function getModems() {
      loading.value = true; // 设置加载状态为 true，表示正在加载数据

      // 获取应用状态管理对象中的调制解调器列表
      let ckmodems = appStore.panes;

      // 如果调制解调器列表为空
      if (!ckmodems) {
        // 调用 get_modem 函数，传入查询参数，获取调制解调器数据
        get_modem(queryParams4).then(res => {
          // 如果 nowtype 为空且返回的数据长度大于 0，将第一个调制解调器的类型赋值给 nowtype
          if (!nowtype.value && res.data.data.result.data.length > 0) {
            nowtype.value = res.data.data.result.data[0].mtype;
          }

          // 如果 nowstep 为空，将第一个调制解调器的 IP 地址赋值给 nowstep 和相关查询参数
          if (!nowstep.value) {
            nowstep.value = res.data.data.result.data[0].ip;
            queryParams3.ip = nowstep.value;
            queryParams5.ip = nowstep.value;
            queryParams6.ip = nowstep.value;
            queryParams7.ip = nowstep.value;
          }

          // 更新应用状态管理对象中的调制解调器列表
          appStore.setPanes(res.data.data.result.data);

          // 设置加载状态为 false，表示数据加载完成
          loading.value = false;
        }).catch(() => {
          // 如果发生错误，设置加载状态为 false
          loading.value = false;
        });
      } else {
        // 如果调制解调器列表不为空

        // 如果 nowtype 为空且应用状态管理对象中的调制解调器列表长度大于 0，将第一个调制解调器的类型赋值给 nowtype
        if (!nowtype.value && appStore.panes.length > 0) {
          nowtype.value = appStore.panes[0].mtype;
        }

        // 如果 nowstep 为空且应用状态管理对象中的调制解调器列表长度大于 0，将第一个调制解调器的 IP 地址赋值给 nowstep 和相关查询参数
        if (!nowstep.value && appStore.panes.length > 0) {
          nowstep.value = appStore.panes[0].ip;
          queryParams3.ip = nowstep.value;
          queryParams5.ip = nowstep.value;
          queryParams6.ip = nowstep.value;
          queryParams7.ip = nowstep.value;
        }
      }
    }

    // 定义一个异步函数 getList7，用于获取第七个列表的数据
    async function getList7() {
      loading.value = true; // 设置加载状态为 true，表示正在加载数据

      // 使用 axios 发起 GET 请求，获取记录数据
      get_record(queryParams7).then(res => {
        // 检查返回的数据长度是否大于 0
        if (res.data.data.result.data.length > 0) {
          dataList7.value = res.data.data.result.data; // 将返回的数据赋值给 dataList7
          paginationOption7.total = res.data.data.result.data_count; // 更新分页选项中的总记录数
          paginationOption7.current = queryParams7.cpn; // 更新分页选项中的当前页码
        }
        loading.value = false; // 设置加载状态为 false，表示数据加载完成
      }).catch(() => {
        loading.value = false; // 如果发生错误，设置加载状态为 false
      });
    }

    // 定义一个函数 changeck，用于处理 IP 和类型的变更
    function changeck(ip: string, type: string) {
      ipData.value = ip; // 将传入的 IP 地址赋值给 ipData
      appStore.setIp(type, ip); // 调用 appStore 的 setIp 方法，更新 IP 和类型

      // 更新 nowstep 和 nowtype 变量，分别存储当前的 IP 地址和类型
      nowstep.value = ip;
      nowtype.value = type;

      // 调用 do_rfin 函数获取 RFIN 数据
      do_rfin();
      // 调用 get_sat 函数获取卫星数据
      get_sat();

      // 检查传入的类型是否为 'MT710A'
      if (type == 'MT710A') {
        // 如果是 'MT710A' 类型，更新多个查询参数的 IP 地址
        queryParams2.ip = ip;
        queryParams3.ip = ip;
        queryParams4.ip = ip;
        queryParams5.ip = ip;
        queryParams6.ip = ip;
        queryParams.ip = ip;
        scanparam.ip = ip;
        getParams.ip = ip;
        startParams.ip = ip;
        endParams.ip = ip;
        bindparam.ip = ip;

        // 清空多个数据列表
        dataList2.value = [];
        dataList3.value = [];
        dataList4.value = [];

        // 调用 getScanParams 函数获取扫描参数
        getScanParams();
        // 调用 getList2 函数获取第二个列表数据
        getList2();
        // 调用 getList3 函数获取第三个列表数据
        getList3();
        // 调用 getModems 函数获取调制解调器列表
        getModems();
        // 调用 do_get_chars 函数获取字符数据
        do_get_chars();
      } else {
        // 如果不是 'MT710A' 类型，更新 queryParams7 的 IP 地址
        queryParams7.ip = ip;
        // 清空 dataList7
        dataList7.value = [];
        // 重置 queryParams7 的页码为 1
        queryParams7.cpn = 1;
        // 调用 getList7 函数获取第七个列表数据
        getList7();
      }
    }

    // 使用 Vue 的 watch 函数监听 appStore.obj 的变化
    watch(
      appStore.obj,
      (newValue, oldValue) => {
        // 当 appStore.obj 发生变化时，调用 do_get_chars 和 getList2 函数
        do_get_chars();
        getList2();
      },
      {
        deep: true // 设置为深度监听，以便监听对象内部属性的变化
      }
    );

    // 定义一个函数 switchsize，用于切换大小状态并执行相关操作
    function switchsize() {
      // 切换 spana1 的值，如果当前值为 24 则变为 18，否则变为 24
      spana1.value = spana1.value == 24 ? 18 : 24;
      // 切换 smallsize 的布尔值
      smallsize.value = smallsize.value == true ? false : true;
      // 调用 do_get_chars 函数获取字符数据
      do_get_chars();
      // 设置一个定时器，延迟 1000 毫秒后调用 resize 函数
      setTimeout(() => {
        resize();
      }, 1000);
    }

    // 使用 useGo 钩子获取 go 函数，用于导航
    const go = useGo();

    // 定义一个函数 go_add，用于导航到调制解调器设置页面
    function go_add() {
      go('/system/modemSet');
    }




    // 定义一个函数 changeck2，用于处理 RFIN 值的变更
    function changeck2(name, id) {
      // 调用 set_rfin 函数，传入新的 RFIN 值和当前 IP 地址
      set_rfin({ rfin: name, ip: appStore.obj.ip }).then((res) => {
        console.log(res, 'res-=-=-=-=0=-0-0-0=-'); // 打印响应数据，便于调试
      });
      // 注释掉的代码：原本可能用于获取卫星数据
      // get_sat()
    }

    // 定义一个函数 do_init，用于初始化数据
    function do_init() {
      loading.value = true; // 设置加载状态为 true，表示正在加载数据

      // 调用 get_term 函数，获取终端数据
      get_term({})
        .then((res) => {
          // 更新 rfinOptions、scanOptions、flockOptions 和 mlockOptions 的值
          // rfinOptions.value = res.data.data.result.data.SELECT.rfin.select;
          scanOptions.value = res.data.data.result.data.SELECT.scan_mode.select;
          flockOptions.value = res.data.data.result.data.SELECT.fec_lock_check.select;
          mlockOptions.value = res.data.data.result.data.SELECT.merger_lock_check.select;
          loading.value = false; // 设置加载状态为 false，表示数据加载完成
        })
        .catch(() => {
          loading.value = false; // 如果发生错误，设置加载状态为 false
        });
    }

    // 定义一个函数 getScanParams，用于获取扫描参数并更新相关状态
    function getScanParams() {
      loading.value = true; // 设置加载状态为 true，表示正在加载数据

      // 更新 getParams 的 rfin 属性为当前的 RFIN 值
      getParams.rfin = nowRfin.value;

      // 使用 axios 发起 GET 请求，获取扫描参数
      get_scanparam(getParams).then(res => {
        // 更新 scanparam 对象的多个属性，包括扫描模式、FEC 锁定检查、合并锁定检查和超时时间
        scanparam.scan_mode = res.data.data.result.data.scan_mode;
        scanparam.fec_lock_check = res.data.data.result.data.fec_lock_check;
        scanparam.merger_lock_check = res.data.data.result.data.merger_lock_check;
        scanparam.out_time = res.data.data.result.data.out_time;

        loading.value = false; // 设置加载状态为 false，表示数据加载完成
      }).catch(() => {
        loading.value = false; // 如果发生错误，设置加载状态为 false
      });
    }

    // 定义一个函数 showEdit，用于显示编辑记录的对话框
    const showEdit = (record) => {
      openEditRecord.value = true; // 设置 openEditRecord 为 true，显示编辑对话框
    };

    // 定义一个函数 dobind，用于处理绑定记录的操作
    const dobind = (record) => {
      bindparam.index = record.index; // 设置 bindparam 的 index 属性为当前记录的索引
      openbindRecord.value = true; // 设置 openbindRecord 为 true，显示绑定对话框
    };

    // 定义一个函数 showEdit1，用于显示编辑 INR 记录的对话框
    const showEdit1 = (record) => {
      inr_value.value = inr.value; // 将当前的 INR 值赋值给 inr_value
      openInrRecord.value = true; // 设置 openInrRecord 为 true，显示编辑 INR 对话框
    };

    // 定义一个异步函数 do_interval_Save，用于保存 INR 值的修改
    async function do_interval_Save() {
      try {
        loading.value = true; // 设置加载状态为 true，表示正在提交数据
        await set_inr({ inr: inr_value.value }); // 调用 set_inr 函数，传入新的 INR 值
        loading.value = false; // 设置加载状态为 false，表示数据提交完成
        message.success('修改成功！'); // 显示成功消息
        getInr(); // 重新获取 INR 数据
        openInrRecord.value = false; // 关闭编辑 INR 对话框
        location.reload(); // 刷新页面
      } catch (error) {
        loading.value = false; // 如果发生错误，设置加载状态为 false
      }
    }

    // 定义一个异步函数 do_Save，用于保存扫描参数的修改
    async function do_Save() {
      try {
        loading.value = true; // 设置加载状态为 true，表示正在提交数据
        await save_scanparam(scanparam); // 调用 save_scanparam 函数，传入新的扫描参数
        loading.value = false; // 设置加载状态为 false，表示数据提交完成
        message.success('修改成功！'); // 显示成功消息
        openEditRecord.value = false; // 关闭编辑记录对话框
        getList7(); // 重新获取第七个列表的数据
      } catch (error) {
        loading.value = false; // 如果发生错误，设置加载状态为 false
      }
    }

    function do_start() {
      startParams.rfin = nowRfin.value
      let isok = ref(true)
      if (startParams.st < 950 || startParams.st > 2150) {
        message.error('范围在950~2150之间！');
        isok.value = false
      }
      if (startParams.end < 950 || startParams.end > 2150) {
        message.error('范围在950~2150之间！');
        isok.value = false
      }
      if (startParams.rs_mix < 1 || startParams.rs_mix > 50) {
        message.error('范围在1~50之间！');
        isok.value = false
      }
      if (startParams.step < 5 || startParams.step > 70) {
        message.error('范围在5~70之间！');
        isok.value = false
      }
      if (startParams.st > startParams.end) {
        message.error('起始频率不能大于结束频率！');
        isok.value = false
      }
      if (isok.value) {
        stscan(startParams)
          .then((res) => {
            loading.value = false;
            message.success('已开始！');
            openEditRecord.value = false
            getList7();
          })
          .catch(() => {
            //message.error("连接超时，请稍后再试！");
            loading.value = false;
          });
      }

    }
    function do_end() {
      endParams.rfin = nowRfin.value
      sscan(endParams)
        .then((res) => {
          loading.value = false;
          message.success('已停止！');
          getList7();
        })
        .catch(() => {
          //message.error("连接超时，请稍后再试！");
          loading.value = false;
        });
    }
    function do_bing_Save() {
      scanset(bindparam)
        .then((res) => {
          loading.value = false;
          message.success('已绑定！');
          openbindRecord.value = false
          getList7();
        })
        .catch(() => {
          //message.error("连接超时，请稍后再试！");
          loading.value = false;
        });
    }
    function do_switch(checked: any, ip: any, chn: any, index: any) {
      saveParams3.status = checked;
      saveParams3.chn = chn;
      saveParams3.ip = ip
      set_status(saveParams3)
        .then((res) => {
          if (res.data.data.result.data.code == 200) {
            dataList3.value[index].stat = checked.value
            message.success('通道开关切换成功！');
            switchLoading[index] = true
          } else {
            dataList3.value[index].stat = checked == 1 ? 0 : 1
            //checked.value=checked.value==1?0:1
            message.error('通道开关切换失败！');
          }
          loading.value = false;
          //getList3();;
        })
        .catch(() => {
          //message.error("连接超时，请稍后再试！");
          loading.value = false;
        });
    }
    function do_get_chars() {
      get_chars(queryParams5).then(res => {
        loading.value = false;
        setTimeout(() => {
          if (res.data.data.result.data) {
            xdata.value = res.data.data.result.data.x
            ydata.value = res.data.data.result.data.y
            setOptions({
              tooltip: {
                trigger: 'axis',
                axisPointer: {
                  lineStyle: {
                    width: 1,
                    color: '#019680',
                  },
                },
              },
              xAxis: {
                type: 'category',
                boundaryGap: false,
                data: xdata.value,
                axisLabel: {
                  interval: 380,
                  //rotate: 315,
                },
              },
              yAxis: [
                {
                  type: 'value',
                  max: -30,
                  min: -130
                },
              ],
              grid: { left: '1%', right: '1%', top: '2  %', bottom: 60, containLabel: true },
              dataZoom: [
                {
                  show: true,
                  realtime: true,
                  backgroundColor: "rgba(47,69,84,0)",
                  start: 0,
                  end: 100,
                  xAxisIndex: [0, 1]
                },
                {
                  type: 'inside',
                  realtime: true,
                  start: 0,
                  end: 100,
                  xAxisIndex: [0, 1]
                }
              ],
              series: [
                {
                  smooth: true,
                  data: ydata.value,
                  type: 'line',
                  itemStyle: {
                    color: '#5C90F9',
                  },
                },
              ],
            });
          } else {
            xdata.value = []
            ydata.value = []
            setOptions({})
          }
        }, 1000);
      }).catch(() => {
        // message.error("连接超时，请稍后再试！");
        loading.value = false
      });
      loading.value = false
    }
    const datax1 = reactive({
      //作为初始和保存用户操作后的范围
      start: 0,
      end: 100,
      //dataZoom的配置，这里我只取了关键点，每个项目配置不一样
      dataZoom: [
        {
          //设定初始范围
          show: true,
          realtime: true,
          backgroundColor: "rgba(47,69,84,0)",
          start: 0,
          end: 100,
          xAxisIndex: [0, 1]
        },
        {
          type: 'inside',
          realtime: true,
          start: 30,
          end: 70,
          xAxisIndex: [0, 1]
        }
      ],
    })

    function do_load_chars() {
      get_chars(queryParams5).then(res => {
        loading.value = false;
        setTimeout(() => {
          if (res.data.data.result.data) {
            xdata.value = res.data.data.result.data.x
            ydata.value = res.data.data.result.data.y
            setOptions({
              tooltip: {
                trigger: 'axis',
                axisPointer: {
                  lineStyle: {
                    width: 1,
                    color: '#019680',
                  },
                },
              },
              xAxis: {
                type: 'category',
                boundaryGap: false,
                data: xdata.value,
                axisLabel: {
                  interval: 380,
                  //rotate: 315,
                },
              },
              yAxis: [
                {
                  type: 'value',
                  max: -30,
                  min: -130
                },
              ],
              grid: { left: '1%', right: '1%', top: '2  %', bottom: 60, containLabel: true },
              dataZoom: datax1.dataZoom,
              series: [
                {
                  smooth: true,
                  data: ydata.value,
                  type: 'line',
                  itemStyle: {
                    color: '#5C90F9',
                  },
                },
              ],
            });
          }
        }, 1000);
      }).catch(() => {
        // message.error("连接超时，请稍后再试！");
        loading.value = false
      });
      loading.value = false
    }

    return {
      dataList,
      dataList2,
      dataList3,
      dataList4,
      dataList7,
      columns2,
      columns3,
      columns4,
      columns7,
      paginationOption2,
      paginationOption3,
      paginationOption4,
      paginationOption7,
      labelCol: { span: 6 },
      wrapperCol: { span: 18 },
      activeKey1,
      activeKey2,
      activeKey3,
      activeKey4,
      img1,
      img2,
      img3,
      nowstep,
      nowtype,
      arr,
      changeck,
      t,
      go_add,
      do_get_chars,
      chartRef,
      visible,
      showModal,
      handleOk,
      appStore,
      nodata1,
      changePageInfo7,
      switchsize,
      spana1,
      smallsize,
      startParams,
      Options,
      openEditRecord,
      showEdit,
      scanparam,
      rfinOptions,
      scanOptions,
      flockOptions,
      timeoutOptions,
      mlockOptions,
      do_Save,
      do_start,
      do_end,
      nowRfin,
      dobind,
      openbindRecord,
      bindparam,
      do_bing_Save,
      progress,
      time,
      columns,
      do_switch,
      do_rfin,
      changeck2,
      loading3,
      inr,
      showEdit1,
      inr_value,
      do_interval_Save,
      openInrRecord,
      rules,
      switchLoading,
      select1,
      typeOptions,
      flag,
      flags,
      values,
      get_sat,
      flag2,
      flag3,
      ipData,
      get_modems
    }
  }

})

</script>

<style lang="less" scoped>
::v-deep .ant-col-18 {
  // flex: 0 0 100%;
  // max-width: 100%;
}

.sele_box {
  width: 100%;
  // height: 50px;
  // margin-left: auto;
  display: flex;
  justify-content: space-between;

  .ipt {
    width: 200px;
    margin-bottom: 10px;
  }
}

.spane1 {
  color: #0960bd;
  cursor: pointer;
}

.list1 {
  padding: 20px 0;
}

.content1 {
  padding: 15px 0;
  text-indent: 24px;
}

.hh1 {
  line-height: 34px;
  text-align: center;
  font-weight: bold;
}

.dd1 {
  line-height: 34px;
}

.dd2 {
  line-height: 34px;
  text-indent: 24px;
}

.dd3 {
  line-height: 34px;
  text-indent: 24px;
  float: right;
  margin: 20px 0;
}

.coll1 {
  margin-bottom: 50px;
}

.menu_list {
  display: flex;
  margin-top: 30px;
  margin-bottom: 30px;
  width: 100%;
  flex-wrap: wrap;
}

.menu_list_item {
  margin: 0;
  width: 200px;
  height: 80px;
  padding: 5px 0;
  //border-radius: 10px;
  text-align: center;
  //border: 5px solid #87e8de;
  color: #08979c;
  background-image: linear-gradient(#4b4b4b, #323232);
  margin-right: 15px;
  position: relative;
  margin-top: 10px;
}

/*
.menu_list_item{
  margin: 0 20px;
  width: 120px;
  height: 120px;
  padding: 30px 0;
  border-radius: 100%;
  text-align: center;
  border: 5px solid #87e8de;
  color: #08979c;
  background: #e6fffb;
}*/
.menu_list_item.iscked {
  color: #096dd9;
  //background: #e6f7ff;
  //border-color: #91d5ff;
  border: 1px solid #096dd9;
}

.menu_list_item.iscked .pa1 {
  color: #fff;
}

.box_tit {
  position: relative;
  padding: 12px 16px;
  padding-left: 40px;
  color: #fff;
  line-height: 22px;
  cursor: pointer;
  transition: all 0.3s;
  box-sizing: border-box;
  border-radius: 0 0 2px 2px;
  border: 1px solid #d9d9d9;
  background: #222222;
}

.box_con {
  overflow: hidden;
  color: #fff;
  background-color: #444;
  box-sizing: border-box;
  border-radius: 0 0 2px 2px;
  border: 1px solid #d9d9d9;
  border-top: 0;
}

.font1 {
  position: relative;
  top: 2px;
}

.icon2 {
  padding-top: 10px;
  margin-left: 20px;
}

.pa1 {
  color: #fff;
  font-size: 16px;
  margin: 0;
  margin-top: 10px;
  line-height: 30px;
  font-weight: bold;
}

.pa2 {
  font-size: 12px;
  color: #93d2fb;
  margin: 0;
  line-height: 20px;
}

.pa3 {
  position: absolute;
  right: 10px;
  top: 0;
  color: red;
  font-weight: bold;
  cursor: pointer;
}

.notice1 {
  width: 100%;
  padding-top: 150px;
  text-align: center;
  color: #fff;
  font-size: 16px;
}

.spanf1 {
  color: #05e618;
}

.char1 {
  background-image: linear-gradient(#535353, #060606);
}

.spanaa1 {
  margin-left: 25px;
}

.tablea1 {
  padding: 20px;
  padding-top: 0;
}

.buttona1 {
  position: absolute;
  z-index: 22;
  right: 10px;
  top: 10px;
  font-size: 24px;
  font-weight: bold;
  color: rgb(82, 196, 26);
}

.boxe1 {
  margin-top: 30px;
}

.ant-input {
  color: #fff;
}

.anticon-close-circle {
  background: #fff;
}

.ant-select-clear {
  background: #3B3D3E;
  color: #fff;
}
</style>
<style>
.moreset {
  float: right;
}

.moreset span {
  color: #93d2fb;
}

.ant-select .ant-select-selection-item {
  color: #fff;
}

.ant-form-item-control-input-content {
  color: #fff;
}

.ant-progress-line {
  width: 70%;
}

.ant-modal-body {
  background: #444;
  ;
}

.ant-progress-text {
  color: #fff;
}

.ant-table-placeholder {
  background: #444;
  color: #fff;
}

.ant-empty-normal {
  color: #fff;
}

.ant-input[disabled] {
  background-color: #ccc !important;
}
</style>
